//class Solution {
//public:
//    vector<int> twoSum(vector<int>& nums, int target) {
//        unordered_map<int, int> hash;
//        for (int i = 0; i < nums.size(); i++) {
//            int cur = nums[i];
//            if (hash.count(target - cur)) {
//                return { hash[target - cur], i };
//            }
//            hash[cur] = i;
//        }
//        return { -1, -1 };
//    }
//};



//func twoSum(nums[]int, target int)[]int{
//    hash: = make(map[int]int)
//    for i, x : = range nums {
//        if p, ok : = hash[target - x]; ok {
//            return[]int{p, i}
//        }
//        hash[x] = i
//    }
//    return[]int{-1, -1}
//}


//class Solution {
//public:
//    vector<vector<string>> groupAnagrams(vector<string>& strs) {
//        unordered_map<string, vector<string>> hash;
//        for (auto& str : strs) {
//            string tmp = str;
//            sort(tmp.begin(), tmp.end());
//            hash[tmp].push_back(str);
//        }
//
//        vector<vector<string>> ret;
//        for (auto [a, b] : hash) {
//            ret.push_back(b);
//        }
//        return ret;
//    }
//};





//func groupAnagrams(strs[]string)[][]string{
//    mp: = map[string][]string{}
//    for _, str : = range strs {
//        tmp: = []byte(str)
//        sort.Slice(tmp, func(i, j int) bool {return tmp[i] < tmp[j]})
//        s : = string(tmp)
//        mp[s] = append(mp[s], str)
//    }
//    ret: = make([][]string, 0, len(mp))
//    for _, v : = range mp {
//        ret = append(ret, v)
//    }
//    return ret
//}



class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int> st(nums.begin(), nums.end());
        int ret = 0;
        for (auto num : st)
        {
            if (st.count(num - 1))
                continue;
            int x = num + 1;
            while (st.count(x))
                x++;
            ret = max(ret, x - num);
        }
        return ret;
    }
};